home *** CD-ROM | disk | FTP | other *** search
/ Young Minds / Young Minds Interactive CD-ROM.ISO / umoria / create.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-07-28  |  11.6 KB  |  502 lines
  1. #include <stdio.h>
  2.  
  3. #include "constants.h"
  4. #include "config.h"
  5. #include "types.h"
  6. #include "externs.h"
  7.  
  8. #ifdef USG
  9. #include <string.h>
  10. #else
  11. #include <strings.h>
  12. #endif
  13.  
  14. #ifdef sun   /* correct SUN stupidity in the stdio.h file */
  15. char *sprintf();
  16. #endif
  17.  
  18. #ifdef USG
  19. unsigned sleep();
  20. #endif
  21.  
  22. #ifdef ultrix
  23. void sleep();
  24. #endif
  25.  
  26. /* Generates character's stats                -JWT-    */
  27. int get_stat()
  28. {
  29.   register int i;
  30.  
  31.   i = randint(4) + randint(4) + randint(4) + 5;
  32.   return(i);
  33. }
  34.  
  35.  
  36. /* Changes stats by given amount                -JWT-    */
  37. byteint change_stat(cur_stat, amount)
  38. byteint cur_stat;
  39. int amount;
  40. {
  41.   register int i;
  42.  
  43.   if (amount < 0)
  44.     for (i = 0; i > amount; i--)
  45.       cur_stat = de_statp(cur_stat);
  46.   else
  47.     for (i = 0; i < amount; i++)
  48.       cur_stat = in_statp(cur_stat);
  49.   return(cur_stat);
  50. }
  51.  
  52.  
  53. /* generate all stats and modify for race... needed in a separate module so
  54.    looping of character selection would be allowed     -RGM- */
  55. void get_stats ()
  56. {
  57.   register player_type *p_ptr;
  58.   register race_type *r_ptr;
  59.  
  60.   p_ptr = &py;
  61.   r_ptr = &race[p_ptr->misc.prace];
  62.   p_ptr->stats.str    = get_stat();
  63.   p_ptr->stats.intel  = get_stat();
  64.   p_ptr->stats.wis    = get_stat();
  65.   p_ptr->stats.dex    = get_stat();
  66.   p_ptr->stats.con    = get_stat();
  67.   p_ptr->stats.chr    = get_stat();
  68.   p_ptr->stats.str    = change_stat(p_ptr->stats.str, r_ptr->str_adj);
  69.   p_ptr->stats.intel  = change_stat(p_ptr->stats.intel, r_ptr->int_adj);
  70.   p_ptr->stats.wis    = change_stat(p_ptr->stats.wis, r_ptr->wis_adj);
  71.   p_ptr->stats.dex    = change_stat(p_ptr->stats.dex, r_ptr->dex_adj);
  72.   p_ptr->stats.con    = change_stat(p_ptr->stats.con, r_ptr->con_adj);
  73.   p_ptr->stats.chr    = change_stat(p_ptr->stats.chr, r_ptr->chr_adj);
  74.   p_ptr->stats.cstr   = p_ptr->stats.str;
  75.   p_ptr->stats.cint   = p_ptr->stats.intel;
  76.   p_ptr->stats.cwis   = p_ptr->stats.wis;
  77.   p_ptr->stats.cdex   = p_ptr->stats.dex;
  78.   p_ptr->stats.ccon   = p_ptr->stats.con;
  79.   p_ptr->stats.cchr   = p_ptr->stats.chr;
  80.   p_ptr->misc.srh    = r_ptr->srh;
  81.   p_ptr->misc.bth    = r_ptr->bth;
  82.   p_ptr->misc.bthb   = r_ptr->bthb;
  83.   p_ptr->misc.fos    = r_ptr->fos;
  84.   p_ptr->misc.stl    = r_ptr->stl;
  85.   p_ptr->misc.save   = r_ptr->bsav;
  86.   p_ptr->misc.hitdie = r_ptr->bhitdie;
  87.   p_ptr->misc.lev    = 1;
  88.   p_ptr->misc.ptodam = todam_adj();
  89.   p_ptr->misc.ptohit = tohit_adj();
  90.   p_ptr->misc.ptoac  = 0;
  91.   p_ptr->misc.pac    = toac_adj();
  92.   p_ptr->misc.expfact = r_ptr->b_exp;
  93.   p_ptr->flags.see_infra = r_ptr->infra;
  94. }
  95.  
  96.  
  97. /* Allows player to select a race            -JWT-    */
  98. int choose_race()
  99. {
  100.   register int j, k;
  101.   int l, m;
  102.   char s;
  103.   int exit_flag;
  104.   char tmp_str[80];
  105.   register player_type *p_ptr;
  106.   register race_type *r_ptr;
  107.   int res;
  108.  
  109.   j = 0;
  110.   k = 0;
  111.   l = 2;
  112.   m = 21;
  113.   clear_screen(20, 0);
  114. /*  help is unimplemented */
  115. /*  prt("Choose a race (? for Help):", 20, 2); */
  116.   prt("Choose a race:", 20, 2);
  117.   do
  118.     {
  119.       (void) sprintf(tmp_str, "%c) %s", k+97, race[j].trace);
  120.       put_buffer(tmp_str, m, l);
  121.       k++;
  122.       l += 15;
  123.       if (l > 70)
  124.     {
  125.       l = 2;
  126.       m++;
  127.     }
  128.       j++;
  129.     }
  130.   while (j < MAX_RACES);
  131.   /* clear race string */
  132.   py.misc.race[0] = '\0';
  133.   move_cursor (20, 18);
  134.   exit_flag = FALSE;
  135.   do
  136.     {
  137.       inkey(&s);
  138.       j = s - 97;
  139.       if ((j < MAX_RACES) && (j >= 0))
  140.     {
  141.       p_ptr = &py;
  142.       r_ptr = &race[j];
  143.       p_ptr->misc.prace  = j;
  144.       (void) strcpy(p_ptr->misc.race, r_ptr->trace);
  145.       get_stats();                  /* We don't need the code twice. */
  146.       exit_flag = TRUE;             /* so use function get_stats -RGM- */
  147.       res = TRUE;
  148.       put_buffer(py.misc.race, 3, 14);
  149.     }
  150.     }
  151.   while (!exit_flag);
  152.   return(res);
  153. }
  154.  
  155.  
  156. /* Will print the history of a character            -JWT-    */
  157. print_history()
  158. {
  159.   register int i;
  160.  
  161.   put_buffer("Character Background", 13, 27);
  162.   for(i = 0; i < 5; i++)
  163.     put_buffer(py.misc.history[i], i+14, 4);
  164. }
  165.  
  166.  
  167. /* Get the racial history, determines social class    -RAK-    */
  168. /* Assumptions:    Each race has init history beginning at     */
  169. /*        (race-1)*3+1                    */
  170. /*        All history parts are in ascending order    */
  171. get_history()
  172. {
  173.   int hist_ptr, cur_ptr, test_roll;
  174.   register int start_pos, end_pos, cur_len;
  175.   int line_ctr, new_start, social_class;
  176.   char history_block[400];
  177.   vtype tmp_str;
  178.   int flag;
  179.   register background_type *b_ptr;
  180.  
  181.   /* Get a block of history text                */
  182.   hist_ptr = py.misc.prace*3 + 1;
  183.   history_block[0] = '\0';
  184.   social_class = randint(4);
  185.   cur_ptr = 0;
  186.   do
  187.     {
  188.       flag = FALSE;
  189.       do
  190.     {
  191.       if (background[cur_ptr].chart == hist_ptr)
  192.         {
  193.           test_roll = randint(100);
  194.           while (test_roll > background[cur_ptr].roll)
  195.         cur_ptr++;
  196.           b_ptr = &background[cur_ptr];
  197.           (void) strcat(history_block, b_ptr->info);
  198.           social_class += b_ptr->bonus;
  199.           if (hist_ptr > b_ptr->next)
  200.         cur_ptr = 0;
  201.           hist_ptr = b_ptr->next;
  202.           flag = TRUE;
  203.         }
  204.       else
  205.         cur_ptr++;
  206.     }
  207.       while (!flag);
  208.     }
  209.   while (hist_ptr >= 1);
  210.  
  211.   /* Process block of history text for pretty output    */
  212.   start_pos = 0;
  213.   end_pos   = strlen(history_block) - 1;
  214.   line_ctr  = 0;
  215.   flag = FALSE;
  216.   while (history_block[end_pos] == ' ')
  217.     end_pos--;
  218.   do
  219.     {
  220.       while (history_block[start_pos] == ' ')
  221.     start_pos++;
  222.       cur_len = end_pos - start_pos + 1;
  223.       if (cur_len > 70)
  224.     {
  225.       cur_len = 70;
  226.       while (history_block[start_pos+cur_len-1] != ' ')
  227.         cur_len--;
  228.       new_start = start_pos + cur_len;
  229.       while (history_block[start_pos+cur_len-1] == ' ')
  230.         cur_len--;
  231.     }
  232.       else
  233.     flag = TRUE;
  234.       (void) strncpy(tmp_str, &history_block[start_pos], cur_len);
  235.       tmp_str[cur_len] = '\0';
  236.       (void) strcpy(py.misc.history[line_ctr], tmp_str);
  237.       line_ctr++;
  238.       start_pos = new_start;
  239.     }
  240.   while (!flag);
  241.  
  242.   /* Compute social class for player            */
  243.   if (social_class > 100)
  244.     social_class = 100;
  245.   else if (social_class < 1)
  246.     social_class = 1;
  247.   py.misc.sc = social_class;
  248. }
  249.  
  250.  
  251. /* Gets the character's sex                -JWT-    */
  252. int get_sex()
  253. {
  254.   char s;
  255.   int exit_flag;
  256.   int sex;
  257.  
  258.   py.misc.sex[0] = '\0';
  259.   clear_screen(20, 0);
  260. /* help is unimplemented */
  261. /*  prt("Choose a sex (? for Help):", 20, 2); */
  262.   prt("Choose a sex:", 20, 2);
  263.   prt("m) Male       f) Female", 21, 2);
  264.   move_cursor (20, 16);
  265.   do
  266.     {
  267.       inkey(&s);
  268.       switch(s)
  269.     {
  270.     case 'f': case 'F':
  271.       (void) strcpy(py.misc.sex, "Female");
  272.       prt(py.misc.sex, 4, 14);
  273.       exit_flag = TRUE;
  274.       sex = TRUE;
  275.       break;
  276.     case 'm': case 'M':
  277.       (void) strcpy(py.misc.sex, "Male");
  278.       prt(py.misc.sex, 4, 14);
  279.       exit_flag = TRUE;
  280.       sex = TRUE;
  281.       break;
  282.     default:
  283.       sex = FALSE;
  284.       exit_flag = FALSE;
  285.       break;
  286.     }
  287.     }
  288.   while (!exit_flag);
  289.   return(sex);
  290. }
  291.  
  292.  
  293. /* Computes character's age, height, and weight        -JWT-    */
  294. get_ahw()
  295. {
  296.   register int i;
  297.  
  298.   i = py.misc.prace;
  299.   py.misc.age = race[i].b_age + randint((int)race[i].m_age);
  300.   switch(py.misc.sex[0])
  301.     {
  302.     case 'F': case 'f':
  303.       py.misc.ht = randnor((int)race[i].f_b_ht, (int)race[i].f_m_ht);
  304.       py.misc.wt = randnor((int)race[i].f_b_wt, (int)race[i].f_m_wt);
  305.       break;
  306.     case 'M': case 'm':
  307.       py.misc.ht = randnor((int)race[i].m_b_ht, (int)race[i].m_m_ht);
  308.       py.misc.wt = randnor((int)race[i].m_b_wt, (int)race[i].m_m_wt);
  309.       break;
  310.     }
  311.   py.misc.disarm = race[i].b_dis + todis_adj();
  312. }
  313.  
  314.  
  315. /* Gets a character class                -JWT-    */
  316. int get_class()
  317. {
  318.   register int i, j;
  319.   int k, l, m;
  320.   int cl[MAX_CLASS];
  321.   char s;
  322.   int exit_flag;
  323.   int res;
  324.   register struct misc *m_ptr;
  325.   register player_type *p_ptr;
  326.   char tmp_str[80];
  327.  
  328.   for (j = 0; j < MAX_CLASS; j++)
  329.     cl[j] = 0;
  330.   i = py.misc.prace;
  331.   j = 0;
  332.   k = 0;
  333.   l = 2;
  334.   m = 21;
  335.   clear_screen(20, 0);
  336. /* help is unimplemented */
  337. /* prt("Choose a class (? for Help):", 20, 2); */
  338.   prt("Choose a class:", 20, 2);
  339.   do
  340.     {
  341.       if (race[i].tclass & bit_array[j])
  342.     {
  343.       (void) sprintf(tmp_str, "%c) %s", k+97, class[j].title);
  344.       put_buffer(tmp_str, m, l);
  345.       cl[k] = j;
  346.       l += 15;
  347.       if (l > 70)
  348.         {
  349.           l = 2;
  350.           m++;
  351.         }
  352.       k++;
  353.     }
  354.       j++;
  355.     }
  356.   while (j < MAX_CLASS);
  357.   py.misc.pclass = 0;
  358.   move_cursor (20, 19);
  359.   exit_flag = FALSE;
  360.   do
  361.     {
  362.       inkey(&s);
  363.       j = s - 97;
  364.       if ((j < k) && (j >= 0))
  365.     {
  366.       (void) strcpy(py.misc.tclass, class[cl[j]].title);
  367.       py.misc.pclass = cl[j];
  368.       exit_flag = TRUE;
  369.       res = TRUE;
  370.       clear_screen(20, 0);
  371.       put_buffer(py.misc.tclass, 5, 14);
  372.  
  373.       /* Adjust the stats for the class adjustment        -RAK-    */
  374.       p_ptr = &py;
  375.       p_ptr->stats.str  = change_stat(p_ptr->stats.str,
  376.                      class[p_ptr->misc.pclass].madj_str);
  377.       p_ptr->stats.intel= change_stat(p_ptr->stats.intel,
  378.                      class[p_ptr->misc.pclass].madj_int);
  379.       p_ptr->stats.wis  = change_stat(p_ptr->stats.wis,
  380.                      class[p_ptr->misc.pclass].madj_wis);
  381.       p_ptr->stats.dex  = change_stat(p_ptr->stats.dex,
  382.                      class[p_ptr->misc.pclass].madj_dex);
  383.       p_ptr->stats.con  = change_stat(p_ptr->stats.con,
  384.                      class[p_ptr->misc.pclass].madj_con);
  385.       p_ptr->stats.chr  = change_stat(p_ptr->stats.chr,
  386.                      class[p_ptr->misc.pclass].madj_chr);
  387.       p_ptr->stats.cstr = p_ptr->stats.str;
  388.       p_ptr->stats.cint = p_ptr->stats.intel;
  389.       p_ptr->stats.cwis = p_ptr->stats.wis;
  390.       p_ptr->stats.cdex = p_ptr->stats.dex;
  391.       p_ptr->stats.ccon = p_ptr->stats.con;
  392.       p_ptr->stats.cchr = p_ptr->stats.chr;
  393.       p_ptr->misc.ptodam = todam_adj();    /* Real values        */
  394.       p_ptr->misc.ptohit = tohit_adj();
  395.       p_ptr->misc.ptoac  = toac_adj();
  396.       p_ptr->misc.pac    = 0;
  397.       p_ptr->misc.dis_td = p_ptr->misc.ptodam; /* Displayed values    */
  398.       p_ptr->misc.dis_th = p_ptr->misc.ptohit;
  399.       p_ptr->misc.dis_tac= p_ptr->misc.ptoac;
  400.       p_ptr->misc.dis_ac = p_ptr->misc.pac;
  401.  
  402.       /* now set misc stats, do this after setting stats because
  403.          of con_adj() for hitpoints */
  404.       m_ptr = &py.misc;
  405.       m_ptr->hitdie += class[m_ptr->pclass].adj_hd;
  406.       m_ptr->mhp = con_adj() + m_ptr->hitdie;
  407.       m_ptr->chp = (double)m_ptr->mhp;
  408.       m_ptr->bth += class[m_ptr->pclass].mbth;
  409.       m_ptr->bthb += class[m_ptr->pclass].mbthb;    /*RAK*/
  410.       m_ptr->srh += class[m_ptr->pclass].msrh;
  411.       m_ptr->disarm += class[m_ptr->pclass].mdis;
  412.       m_ptr->fos += class[m_ptr->pclass].mfos;
  413.       m_ptr->stl += class[m_ptr->pclass].mstl;
  414.       m_ptr->save += class[m_ptr->pclass].msav;
  415.       (void) strcat(m_ptr->title, player_title[m_ptr->pclass][0]);
  416.       m_ptr->expfact += class[m_ptr->pclass].m_exp;
  417.  
  418.     }
  419.     }
  420.   while (!exit_flag);
  421.   return(res);
  422. }
  423.  
  424.  
  425. get_money()
  426. {
  427.   register int tmp;
  428.   register struct stats *p_ptr;
  429.   register struct misc *m_ptr;
  430.  
  431.   p_ptr = &py.stats;
  432.   tmp = p_ptr->cstr + p_ptr->cint + p_ptr->cwis +
  433.     p_ptr->cdex + p_ptr->ccon + p_ptr->cchr;
  434.   m_ptr = &py.misc;
  435.   m_ptr->au = m_ptr->sc*6 + randint(25) + 325;    /* Social Class adj    */
  436.   m_ptr->au = m_ptr->au - tmp;            /* Stat adj        */
  437.   m_ptr->au = m_ptr->au + p_ptr->cchr;        /* Charisma adj    */
  438.   if (m_ptr->au < 80)  m_ptr->au = 80;        /* Minimum        */
  439. }
  440.  
  441.  
  442. /* ---------- M A I N  for Character Creation Routine ---------- */
  443. /*                            -JWT-    */
  444. create_character()
  445. {
  446.   char s;
  447.   register int exit_flag = 1;
  448.  
  449.   put_character();
  450.   (void) choose_race();
  451.   (void) get_sex();
  452.  
  453.   /* here we start a loop giving a player a choice of characters -RGM- */
  454.   get_stats ();
  455.   get_history();
  456.   get_ahw();
  457.   put_character();
  458.   print_history();
  459.   put_misc1();
  460.   put_stats();
  461.   exit_flag = 1;
  462.   do
  463.     {
  464.       prt("Hit space to reroll or ESC to accept characteristics: ", 20, 2);
  465.       inkey(&s);
  466.       switch (s)
  467.     {
  468.     case 27:
  469.       exit_flag = 0;
  470.       break;
  471.     case ' ':
  472.       get_stats ();
  473.       get_history();
  474.       get_ahw();
  475.       put_character();
  476.       print_history();
  477.       put_misc1();
  478.       put_stats();
  479. #ifdef SLOW
  480.       (void) sleep (0);
  481. #endif      
  482.       break;
  483.     default:
  484.       break;
  485.     }
  486.     }               /* done with stats generation */
  487.   while (exit_flag == 1);
  488.  
  489.   (void) get_class();
  490.   get_money();
  491.   put_stats();
  492.   put_misc2();
  493.   put_misc3();
  494.   get_name();
  495.  
  496.   /* This delay may be reduced, but is recommended to keep players    */
  497.   /* from continuously rolling up characters, which can be VERY    */
  498.   /* expensive CPU wise.                        */
  499.   pause_exit(23, PLAYER_EXIT_PAUSE);
  500. }
  501.  
  502.